package com.yunquan.ohana.view

import android.animation.ValueAnimator
import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.graphics.Rect
import android.graphics.RectF
import android.graphics.Typeface
import android.os.Build
import android.util.AttributeSet
import android.view.View
import androidx.core.content.res.ResourcesCompat
import com.yunquan.ohana.R
import com.yunquan.ohana.utils.Utils

class CircularProgressBar @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

    // 进度条属性
    private var bgColor: Int = Color.LTGRAY // 背景环颜色
    private var progressColor: Int = Color.BLUE // 进度环颜色
    private var ringWidth: Float = 12f // 环的宽度（dp转px后的值）
    private var centerColor: Int = Color.RED // 中间实心圆颜色
    private var progress: Int = 0 // 当前进度（0~maxProgress）
    private var maxProgress: Int = 100 // 最大进度
    private var centerTextFontResId: Int = -1 // 字体资源ID（res/font目录，如R.font.my_font）
    private var centerTextTypeface: Typeface? = null // 文本字体（缓存，避免重复加载）

    // 中间内容属性
    private var centerIcon: Bitmap? = null // 中间图标
    private var centerText: String = "D" // 中间文字
    private var centerTextColor: Int = Color.WHITE // 文字颜色
    private var centerTextSize: Float = 40f // 文字大小（sp转px后的值）

    // 画笔
    private val bgPaint = Paint(Paint.ANTI_ALIAS_FLAG) // 背景环画笔
    private val progressPaint = Paint(Paint.ANTI_ALIAS_FLAG) // 进度环画笔
    private val centerPaint = Paint(Paint.ANTI_ALIAS_FLAG) // 中间实心圆画笔
    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG) // 文字画笔

    init {
        // 加载自定义属性
        val typedArray = context.obtainStyledAttributes(attrs, R.styleable.CircularProgressBar)
        try {
            // 进度条属性
            bgColor = typedArray.getColor(R.styleable.CircularProgressBar_bgColor, bgColor)
            progressColor = typedArray.getColor(R.styleable.CircularProgressBar_progressColor, progressColor)
            centerColor = typedArray.getColor(R.styleable.CircularProgressBar_centerColor, centerColor)
            ringWidth = typedArray.getDimension(R.styleable.CircularProgressBar_ringWidth, ringWidth)
            progress = typedArray.getInt(R.styleable.CircularProgressBar_progress, progress)
            maxProgress = typedArray.getInt(R.styleable.CircularProgressBar_maxProgress, maxProgress)

            // 中间内容属性
            val centerIconRes = typedArray.getResourceId(R.styleable.CircularProgressBar_centerIcon, 0)
            if (centerIconRes != 0) {
                centerIcon = BitmapFactory.decodeResource(resources, centerIconRes)
            }
            centerText = typedArray.getString(R.styleable.CircularProgressBar_centerText) ?: centerText
            centerTextColor = typedArray.getColor(
                R.styleable.CircularProgressBar_centerTextColor,
                centerTextColor
            )
            centerTextSize = typedArray.getDimension(
                R.styleable.CircularProgressBar_centerTextSize,
                centerTextSize
            )
            // 新增：加载字体家族属性（默认使用系统字体）
            centerTextFontResId = typedArray.getResourceId(R.styleable.CircularProgressBar_centerTextFontFamily, -1)
        } finally {
            typedArray.recycle()
        }

        // 初始化画笔
        initPaints()
    }

    /**
     * 初始化画笔配置
     */
    private fun initPaints() {
        // 背景环画笔
        bgPaint.apply {
            color = bgColor
            style = Paint.Style.STROKE //  stroke=环，fill=实心
            strokeWidth = ringWidth
        }
        // 进度环画笔（端点圆角，更圆润）
        progressPaint.apply {
            color = progressColor
            style = Paint.Style.STROKE
            strokeWidth = ringWidth
            strokeCap = Paint.Cap.BUTT // 端点圆角
        }
        // 中间实心圆画笔
        centerPaint.apply {
            color = centerColor
            style = Paint.Style.FILL // 实心
        }
        // 文字画笔（居中对齐）
        textPaint.apply {
            color = centerTextColor
            textSize = centerTextSize
            textAlign = Paint.Align.CENTER // 文字水平居中
            // 设置字体家族（优先使用自定义字体，否则用系统默认）
            centerTextTypeface = loadTypeface(context)
            typeface = centerTextTypeface ?: Typeface.DEFAULT
        }
    }

    /**
     * 测量View尺寸（处理wrap_content的情况）
     */
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        val desiredSize = resources.getDimensionPixelSize(R.dimen.dp_200)// 默认大小（200dp）
        val width = measureDimension(desiredSize, widthMeasureSpec)
        val height = measureDimension(desiredSize, heightMeasureSpec)
        val size = minOf(width, height) // 取最小边，保证是正方形
        setMeasuredDimension(size, size)
    }

    /**
     * 测量单个维度（width/height）
     */
    private fun measureDimension(desiredSize: Int, measureSpec: Int): Int {
        val mode = MeasureSpec.getMode(measureSpec)
        val size = MeasureSpec.getSize(measureSpec)
        return when (mode) {
            MeasureSpec.EXACTLY -> size // match_parent或固定值
            MeasureSpec.AT_MOST -> minOf(desiredSize, size) // wrap_content（不超过父容器）
            else -> desiredSize // 未指定（如ListView中的item）
        }
    }

    /**
     * 绘制进度条
     */
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        val centerX = width / 2f // 圆心X坐标（View中心）
        val centerY = height / 2f // 圆心Y坐标（View中心）
        val ringRadius = (minOf(centerX, centerY) - ringWidth / 2) // 圆环半径（避免超出View边界）
        // 1. 绘制背景环（灰色）
        drawBackgroundRing(canvas, centerX, centerY, ringRadius)
        // 2. 绘制进度环（橙色，从顶部开始）
        drawProgressRing(canvas, centerX, centerY, ringRadius)
        // 3. 绘制中间实心圆（深橙）
        drawCenterCircle(canvas, centerX, centerY, ringRadius)
        // 4. 绘制中间内容（图标优先于文字）
        drawCenterContent(canvas, centerX, centerY)
    }

    /**
     * 绘制背景环
     */
    private fun drawBackgroundRing(canvas: Canvas, centerX: Float, centerY: Float, radius: Float) {
        val rect = RectF(centerX - radius, centerY - radius, centerX + radius, centerY + radius)
        canvas.drawArc(rect, 0f, 360f, false, bgPaint) // 绘制360度完整圆环
    }

    /**
     * 绘制进度环（从顶部开始，逆时针增长）
     */
    private fun drawProgressRing(canvas: Canvas, centerX: Float, centerY: Float, radius: Float) {
        if (progress == 0) return // 进度为0时不绘制
        val rect = RectF(centerX - radius, centerY - radius, centerX + radius, centerY + radius)
        val sweepAngle = (progress.toFloat() / maxProgress) * -360f // 进度对应的角度（0~360）
        canvas.drawArc(rect, -90f, sweepAngle, false, progressPaint) // -90度=顶部起始
    }

    /**
     * 绘制中间实心圆（半径=圆环半径-环宽，与圆环内侧对齐）
     */
    private fun drawCenterCircle(
        canvas: Canvas,
        centerX: Float,
        centerY: Float,
        ringRadius: Float
    ) {
        val centerRadius = ringRadius - ringWidth / 2 // 中间圆半径（比圆环小，避免重叠）
        canvas.drawCircle(centerX, centerY, centerRadius, centerPaint)
    }

    /**
     * 绘制中间内容（优先显示图标，无图标则显示文字）
     */
    private fun drawCenterContent(canvas: Canvas, centerX: Float, centerY: Float) {
        // 1. 绘制图标（如果有）
        centerIcon?.let { icon ->
            val iconX = centerX - icon.width / 2f // 图标X坐标（中心对齐）
            val iconY = centerY - icon.height / 2f // 图标Y坐标（中心对齐）
            canvas.drawBitmap(icon, iconX, iconY, null)
            return
        }

        // 2. 绘制文字（无图标时）
        val textBounds = Rect()
        textPaint.getTextBounds(centerText, 0, centerText.length, textBounds)
        val textY = centerY + textBounds.height() / 2f // 文字基线（垂直居中）
        canvas.drawText(centerText, centerX, textY, textPaint)
    }

    /**
     * 外部接口：设置进度（0~maxProgress）
     * @param progress 目标进度（会自动限制在0~maxProgress之间）
     */
    fun setProgress(progress: Int, maxProgress: Int) {
        this.maxProgress = maxProgress
        this.progress = progress.coerceIn(0, maxProgress) // 限制进度范围
        invalidate() // 重绘View（刷新进度）
    }

    /**
     * 外部接口：设置进度（带动画，更流畅）
     * @param progress 目标进度
     * @param duration 动画时长（默认500ms）
     */
    fun setProgressWithAnimation(progress: Int, maxProgress: Int, duration: Long = 500) {
        this.maxProgress = maxProgress
        val targetProgress = progress.coerceIn(0, maxProgress)
        if (this.progress == targetProgress) return // 进度无变化，无需动画
        // 使用属性动画渐变进度
        val animator = ValueAnimator.ofInt(this.progress, targetProgress)
        animator.duration = duration
        animator.addUpdateListener { animation ->
            this.progress = animation.animatedValue as Int
            invalidate() // 每帧重绘
        }
        animator.start()
    }

    // ==================== 新增开放接口 ====================
    /**
     * 设置中间文本内容（若有图标，文本不会显示）
     * @param text 目标文本（为空时显示默认值"D"）
     */
    fun setCenterText(text: String) {
        this.centerText = text.ifEmpty { "D" }
        invalidate()
    }

    /**
     * 设置进度环颜色
     * @param color 目标颜色（如Color.RED）
     */
    fun setProgressColor(color: Int) {
        this.progressColor = color
        progressPaint.color = color
        invalidate()
    }

    /**
     * 设置进度环背景颜色
     * @param color 目标颜色（如Color.RED）
     */
    fun setProgressBgColor(color: Int) {
        this.bgColor = color
        bgPaint.color = color
        invalidate()
    }

    /**
     * 设置中间实心圆颜色
     * @param color 目标颜色（如Color.BLUE）
     */
    fun setCenterColor(color: Int) {
        this.centerColor = color
        centerPaint.color = color
        invalidate()
    }

    /**
     * 设置中间文本颜色
     * @param color 目标颜色（如Color.BLACK）
     */
    fun setCenterTextColor(color: Int) {
        this.centerTextColor = color
        textPaint.color = color
        invalidate()
    }

    /**
     * 设置圆环宽度
     * @param width 宽度（dp转px后的值）
     */
    fun setRingWidth(width: Float) {
        this.ringWidth = width
        bgPaint.strokeWidth = width
        progressPaint.strokeWidth = width
        invalidate()
    }

    /**
     * 清除中间图标（显示文本）
     */
    fun clearCenterIcon() {
        this.centerIcon = null
        invalidate()
    }

    /**
     * 加载字体（系统字体/自定义字体）
     * @param context 上下文
     * @return Typeface? 加载成功的字体，失败返回null
     */
    private fun loadTypeface(context: Context): Typeface? {
        return try {
            when {
                // 1. 优先加载res/font中的资源（如@font/my_font）
                centerTextFontResId != -1 -> {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        // Android 8.0+：直接使用Resources.getFont()
                        context.resources.getFont(centerTextFontResId)
                    } else {
                        // 低版本兼容：使用ResourcesCompat.getFont()（需依赖androidx.core）
                        ResourcesCompat.getFont(context, centerTextFontResId)
                    }
                }
                // 3. 默认：系统默认字体
                else -> {
                    Typeface.DEFAULT
                }
            }
        } catch (e: Exception) {
            // 容错：加载失败时使用默认字体
            e.printStackTrace()
            Typeface.DEFAULT
        }
    }
}